#include <QDir>
#include <QPainter>
#include <QDebug>
#include <QHBoxLayout>
#include <QVector>
#include <QImageReader>
#include <QMovie>
#include <QCoreApplication>

#include "pixplaylabel.h"


PixPlayLabel::PixPlayLabel(uint number, QWidget *parent):
    QLabel(parent), mNumber(number)
{

    endFlag = true;
    isPlayStop = true;
    setAttribute(Qt::WA_TranslucentBackground);
//    setWindowFlags(Qt::WindowStaysOnTopHint);


    init();
}
PixPlayLabel::~PixPlayLabel()
{
    delete mFlyTimer;
    delete showTimer;
    delete rotateTimer;
    delete wBTImer;
    delete foTimer;
    delete mNormalTimer;
    delete stopTimer;
    delete movie;

    for(int i = 0; i < maxBlindsNum; i++)
    {
        delete wbItem[i];
    }

}

/*******************************************
  description:初始化函数，主要用来定义各个播放方式的定时器和一些参数
  parameter：
  ******************************************/
void PixPlayLabel::init()
{
    mFlyTimer = new QTimer(this);
    showTimer = new QTimer(this);
    rotateTimer = new QTimer(this);
    wBTImer = new QTimer(this);
    foTimer = new QTimer(this);
    mNormalTimer = new QTimer(this);
    stopTimer = new QTimer(this);


    showTimer->setSingleShot(true);
    stopTimer->setSingleShot(true);

    connect(mFlyTimer, SIGNAL(timeout()), this, SLOT(flyTimerSlot()));
    connect(showTimer, SIGNAL(timeout()), this, SLOT(showTimerSlot()));
    connect(rotateTimer, SIGNAL(timeout()), this, SLOT(rorateTimerSlot()));
    connect(wBTImer, SIGNAL(timeout()), this, SLOT(windowBlindsTimerSlot()));
    connect(foTimer, SIGNAL(timeout()), this, SLOT(fadeOutTimerSlot()));
    connect(mNormalTimer, SIGNAL(timeout()), this, SLOT(normalTimerSlot()));
    connect(stopTimer, SIGNAL(timeout()), this, SLOT(changePix()));

    mWidth = 400;
    mHeight = 400;

    mPlayNum = 0;
    mTimeId = SHOWTIME;
    mFlyPosK = mWidth;
    rorateDegrees = RORATEDEGREES;

    mWidthK = 0.1;
    openness = 0.1;

    playType = NORMALTYPE;
    mTimerK = FLYTIMERK;

    movie = new QMovie();
    isGifPix = false;

    QHBoxLayout* hlay = new QHBoxLayout;
    hlay->setSpacing(0);
    hlay->setContentsMargins(0, 0, 0, 0);
    setLayout(hlay);

    for(int i = 0; i < maxBlindsNum; ++i)
    {
            wbItem[i] = new WindowBlindsItem(this);
            hlay->addWidget(wbItem[i]);
            wbItem[i]->hide();
    }

}


/*******************************************
  description:切换图片，对播放文件夹内的各个图片进行播放
  parameter：
  ******************************************/
void PixPlayLabel::changePix()
{

    playDuration = cntList.at(mPlayNum).duration * 1000;
    QString pixFile = cntList.at(mPlayNum).contentFile;


    if (isGifPix)
    {
        movie->stop();
        this->clear();
        isGifPix = false;
    }

    //如果是GIF的话则进行相应的扩展


    mPlayNum++;
    //如果当前图片加载失败的话，则加载下一张图片
   // mImg.load(pixFile);
    //ivan @2011.09.30 modify



    QString fullPath(g_installPath);
//    QString fullPath;
    fullPath.append("/");
    fullPath.append(pixFile);

#ifdef DEBUG
    qDebug() << "pixFile------------------------<" << fullPath;
#endif

    //ivan @2011.10.09 add
    fullPath.replace("\\", "/");

    QFile file(fullPath);
    if (!file.exists())
    {
        logger()->warn("Image \"%1\" can't find\n", fullPath);
    }
//    qDebug() << "pixFile------------------------<" << fullPath;

    mImg.load(fullPath);

    //图片进行相应的缩放，让它适配界面的大小
    mImg = mImg.scaled(mWidth, mHeight);
    mPixmap = QPixmap::fromImage(mImg);

    if (pixFile.contains(".gif"))
    {
        movie->setFileName(pixFile);
        isGifPix = true;

        if (playType == NORMALTYPE)
        {
            this->setMovie(movie);
            movie->start();
        }
    }

    //如果全部浏览完则重新开始循环
    if(mPlayNum >= cntListCount)
    {
        mPlayNum = 0;
    }
}

/*******************************************
  description:百味窗播放方式,百味窗的播放构思：先设定好要出现的叶子数，
                 然后将每个叶子设定好它的位置，大小和要显示的哪一部分的图片，
                 接着像播放动画的形式将每个叶子从0到最终大小播放出来
  parameter：
  ******************************************/
void PixPlayLabel::windowBlindsPlay()
{

//    {
//            // 添加要显示的文字
//            QFont font;
//            font.setFamily(QString::fromUtf8("Aharoni"));
//            font.setBold(true);
//            font.setItalic(true);
//            font.setPointSize(99);

//            QPainter painter(&mImg);
//            painter.begin(this);
//            painter.setFont(font);
//            painter.setPen(QPen(Qt::green));
//            painter.drawText(0, mImg.height()-50, QString("Hello  ............."));
//            painter.end();
//    }

            // 分成N个栏，每一栏是一个小的QLabel
            // Layout

    for(int i = 0; i < maxBlindsNum; ++i)
    {
        //设置大小
        wbItem[i]->setFixedWidth(mWidth/maxBlindsNum); // 整个窗体宽度/叶数

        //设置图片
        QImage image = mImg.copy(i*mWidth/maxBlindsNum, 0, mWidth/maxBlindsNum, mHeight);
        wbItem[i]->setImage(image);

        //显示第一片叶子
        if (wbItem[i]->isHidden())
        {
            wbItem[i]->show();
        }
    }

    //开始动画
    mTimeId = playDuration / 5;

    //如果是GIF图片的话，则进行图片自己的动作
    if (isGifPix)
    {
        wBTImer->start(playDuration - 100);

        //隐藏掉窗口最前面的叶子，以免挡住gif图片的显示
        for(int i = 0; i< maxBlindsNum; i++)
        {
            wbItem[i]->hide();
        }
        this->setMovie(movie);
        movie->start();

        return;
    }

    for(int i = 0; i < maxBlindsNum; i++)
    {
        wbItem[i]->startDraw(mTimeId);
    }


    //百味窗定时器启动
    if (mTimeId < 1000)
        mTimeId = 1500;
    wBTImer->start(mTimeId);
}

void PixPlayLabel::playGif()
{
    movie->start();
    update();
}

 void PixPlayLabel::initList()
 {
     reTainCntList.clear();

 }

/*******************************************
  description:设置播放图片内容列表
  parameter：

  ******************************************/
void PixPlayLabel::updatePlayCntList(const QList<ContentStruct>& cntStructList)
{
    for(int i = 0; i < cntStructList.count(); i++)
    {
        reTainCntList.append(cntStructList.at(i));
    }
    cntListCount = cntStructList.count();
}

void PixPlayLabel::setPlayCntList(const QList<ContentStruct>& cntStructList)
{
    reTainCntList.clear();
    for(int i = 0; i < cntStructList.count(); i++)
    {
        reTainCntList.append(cntStructList.at(i));
    }
    cntListCount = cntStructList.count();
    mPlayNum = 0;
}

/*******************************************
  description:开始播放，先初始化参数，根据相应播放方式播放
  parameter：

  ******************************************/
bool PixPlayLabel::start()
{
    if (reTainCntList.isEmpty())
    {
        return false;
    }
    isPlayStop = false;

    mTimeId = 700;
    mFlyPosK = mWidth;
    rorateDegrees = -180;

    mWidthK = 0.1;
    openness = 0.1;
    mPlayNum = 0;
    cntList.clear();
    cntList = reTainCntList;
//    playDuration = cntList.at(mPlayNum).duration * 1000;
//    mTimeId = playDuration / 5;

//    //如果动作时间太长的话，则规定在3秒之内
//    if (mTimeId >= PLAYTIME)
//    {
//        mTimeId = PLAYTIME;
//    }

//    showTime = playDuration - mTimeId;

    playTypeStart(playType);

    //将上一个播放方式的所有定时器全部关闭，重新开启相对应的定时器或初始化工作

    return true;
}

/*******************************************
  description:停止播放，关闭所有的播放方式
  parameter：

  ******************************************/
bool PixPlayLabel::stop()
{

//    qDebug() << "into stop................";
    mTimeId = 700;
    mFlyPosK = mWidth;
    rorateDegrees = -180;

    mWidthK = 0.1;
    openness = 0.1;

    showTimer->stop();
    mNormalTimer->stop();
    mFlyTimer->stop();
    rotateTimer->stop();
    wBTImer->stop();
    foTimer->stop();

    for(int i = 0; i < maxBlindsNum; i++)
    {
        wbItem[i]->stopDraw();
        if (playType != WINDOWBLINDTYPE)
             wbItem[i]->hide();
    }


    return true;
}

bool PixPlayLabel::isStop()
{
    return isPlayStop;
}

void PixPlayLabel::playTypeStart(PLAYTYPE emPlayType)
{


    playDuration = cntList.at(mPlayNum).duration * 1000;
    mTimeId = playDuration / 5;

    //如果动作时间太长的话，则规定在3秒之内
    if (mTimeId >= PLAYTIME)
    {
        mTimeId = PLAYTIME;
    }

    showTime = playDuration - mTimeId;

    playType = emPlayType;

    if(showTimer->isActive())
    {
        showTimer->stop();
    }

    if(emPlayType == NORMALTYPE)
    {
        //普通播放方式
        //将上一个播放方式的所有定时器全部关闭，重新开启相对应的定时器或初始化工作

        if(showTimer->isActive())
        {
            showTimer->stop();
        }

        //停止其它相应的定时器
        if (mFlyTimer->isActive())
        {
            mFlyTimer->stop();
        }

        if (rotateTimer->isActive())
        {
            rotateTimer->stop();
        }

        if(wBTImer->isActive())
        {
            wBTImer->stop();
        }

        for(int i = 0; i < maxBlindsNum; i++)
        {
            wbItem[i]->stopDraw();
            wbItem[i]->hide();
        }

        if (foTimer->isActive())
        {
            foTimer->stop();
        }

        changePix();
        mNormalTimer->start(playDuration);

    } else if(emPlayType == FLYTYPE)
    {
        //飞入播放模式
        //停止其它相应的定时器

        if (mNormalTimer->isActive())
        {
            mNormalTimer->stop();
        }

        if (rotateTimer->isActive())
        {
            rotateTimer->stop();
        }

        if(wBTImer->isActive())
        {
            wBTImer->stop();
        }

        for(int i = 0; i < maxBlindsNum; i++)
        {
            wbItem[i]->stopDraw();
            wbItem[i]->hide();
        }

        if(foTimer->isActive())
        {
            foTimer->stop();
        }

        changePix();
        mTimerK = FLYTIMERK;
        mFlyTimer->start(mTimeId / mTimerK);

    } else if (emPlayType == RORATETYPE)      //旋转播放模式
    {
        //停止其它相应的定时器
        if (mNormalTimer->isActive())
        {
            mNormalTimer->stop();
        }

        if (mFlyTimer->isActive())
        {
            mFlyTimer->stop();
        }

        if(wBTImer->isActive())
        {
            wBTImer->stop();
        }

        for(int i = 0; i < maxBlindsNum; i++)
        {
            wbItem[i]->stopDraw();
            wbItem[i]->hide();
        }

        if(foTimer->isActive())
        {
            foTimer->stop();
        }

        changePix();
        mTimerK = RORATETIMERK;
        rotateTimer->start(mTimeId / mTimerK);

    } else if (emPlayType == WINDOWBLINDTYPE)     //百叶窗播放模式
    {
        //停止其它相应的定时器
        if (mNormalTimer->isActive())
        {
            mNormalTimer->stop();
        }

        if (rotateTimer->isActive())
        {
            rotateTimer->stop();
        }

        if (mFlyTimer->isActive())
        {
            mFlyTimer->stop();
        }

        if(foTimer->isActive())
        {
            foTimer->stop();
        }

        mTimerK = WINDOWBLINDTIMEK;
        windowBlindsPlay();

    } else if (emPlayType == FADEOUTTYPE)        //淡出播放模式
    {
        //停止其它相应的定时器
        if (mNormalTimer->isActive())
        {
            mNormalTimer->stop();
        }

        if (mFlyTimer->isActive())
        {
            mFlyTimer->stop();
        }

        if (rotateTimer->isActive())
        {
            rotateTimer->stop();
        }

        if(wBTImer->isActive())
        {
            wBTImer->stop();
        }

        for(int i = 0; i < maxBlindsNum; i++)
        {
            wbItem[i]->stopDraw();
            wbItem[i]->hide();
        }

        foTimer->start(mTimeId/mTimerK);
    } else {
        this->startTimer(mTimeId);
    }

    update();

}


/*******************************************
  description:设置播放方式
  parameter：
  emPlayType 枚举类型，总共有4种播放方式
    FLYTYPE,            飞入模式
    RORATETYPE,         旋转模式
    WINDOWBLINDTYPE,    百叶窗模式
    FADEOUTTYPE,        淡出模式

  ******************************************/
void PixPlayLabel::setPlayType(PLAYTYPE emPlayType)
{
    playType = emPlayType;
    this->stop();
}


/*******************************************
  description: 重定义的setGeometry，设置位置和大小
  parameter：
    x:  x坐标
    y:  y坐标
    w:  宽度
    h:  高度
  ******************************************/
void PixPlayLabel::setGeometry(int x, int y, int w, int h)
{

    //得到界面的大小
    mWidth = w;
    mHeight = h;
    mFlyPosK = mWidth;

//    qDebug() << "w====>" << w << "h====>" << h;
    //重新调用原来默认的setGeometry
    QLabel::setGeometry(x, y, w, h);
}


/*******************************************
  description: 重定义的timerEvent，定时器事件
  parameter：
  ******************************************/
void PixPlayLabel::timerEvent(QTimerEvent *)
{
    QString pixFile = mPixFileInfoList.at(mPlayNum).absoluteFilePath();

    if(pixFile.contains("."))
    {
        QStringList nameList = pixFile.split(".");
        QString fileFormat = nameList.at(1);

        if (fileFormat == "gif")
        {
//            QMovie *movie = new QMovie(pixFile);
//            pictureLabel->setMovie(movie);
//            movie->start();
            isGifPix = true;
        } else {
            isGifPix = false;
        }


//        mPixmap.load(pixFile);
//        mImg.load(pixFile);
        //ivan @2011.09.30 modify
        QString fullPath(g_installPath);
        fullPath.append("/");
        fullPath.append(pixFile);

        //ivan @2011.10.09 add
        fullPath.replace("\\", "/");
        mPixmap.load(fullPath);
        mImg.load(pixFile);
    }

    //如果全部浏览完则重新开始循环
    mPlayNum++;
    if(mPlayNum >= (mPixFileInfoList.count() - 2))
    {
        mPlayNum = 0;
    }
    this->update();

}


/*******************************************
  description: 重定义的showEvent，显示事件，当调用show()时则调用此函数
  parameter：
  ******************************************/
void PixPlayLabel::showEvent(QShowEvent *e)
{
    //调用相 设置播放方式 函数
    this->setPlayType(playType);
    QLabel::showEvent(e);
 }

/*******************************************
  description: 重定义的hideEvent，隐藏事件，当调用hide()时则调用此函数，
                  此时关闭所有播放方式的定时器
  parameter：
  ******************************************/
void PixPlayLabel::hideEvent(QHideEvent *e)
{

    //停止所有的定时器
    if(showTimer->isActive())
    {
        showTimer->stop();
    }

    if (mFlyTimer->isActive())
    {
        mFlyTimer->stop();
    }

    if (rotateTimer->isActive())
    {
        rotateTimer->stop();
    }

    if(wBTImer->isActive())
    {
        wBTImer->stop();
    }

    if(foTimer->isActive())
    {
        foTimer->stop();
    }
    for(int i = 0; i < maxBlindsNum; i++)
    {
        wbItem[i]->stopDraw();
        wbItem[i]->hide();
    }
//    killTimer(mTimeId);
    mTimeId = 0;
    QLabel::hideEvent(e);
}


/*******************************************
  description: 重定义的paintEvent，绘制事件，当调用update()或repaint()时一般会调用此函数，
                  再根据相对应的播放方式进行相对的绘制图片
  parameter：
  ******************************************/
void PixPlayLabel::paintEvent(QPaintEvent *event)
{
/*
    水面倒影效果
    QPoint start(0,0);
    QPoint end(0,mImg.height()/2); //倒影高度为原图一半
    QLinearGradient gradient(start, end);//设置线性渐变
    gradient.setColorAt(0.5, Qt::white);
    gradient.setColorAt(1, Qt::black);//渐变颜色

    QImage mask = mImg;
    QPainter painter(&mask);
    painter.fillRect(mImg.rect(), gradient);//渐变填充在mask图片上
    painter.end();

    QImage reflection = mImg.mirrored(); //取镜面图
    reflection.setAlphaChannel(mask);   //将线性渐变用于reflection图像

    QPainter p(this);

    p.drawImage(20,20,mImg);  //画出原图
    p.setOpacity(0.8);                  //设置透明度
    p.drawImage(20,20+mImg.height(),reflection);//将reflection图片显示于原图下方

    QTransform transform;
    transform.rotate(30,Qt::YAxis);
    p.setTransform(transform);

    p.setRenderHints(QPainter::Antialiasing|QPainter::HighQualityAntialiasing, true);
*/
    QPainter painter(this);

    if (isGifPix)
    {
        QLabel::paintEvent(event);
        return;
    }

    if (playType == NORMALTYPE)
    {
        painter.drawImage(0,  0, mImg);
        QLabel::paintEvent(event);

    } else if (playType == FLYTYPE)
    {
        //飞入模式 只需要在相应位置进行绘制图片
        painter.drawImage(0,  mFlyPosK, mImg);

    } else if (playType == RORATETYPE)
    {

        //旋转模式
        //使图片的中心作为旋转的中心
        painter.translate(mPixmap.width() / 2, mPixmap.height() / 2);

        //顺时针旋转角度rorateDegrees
        painter.rotate(rorateDegrees);

         //将原点复位
        painter.translate(-1 * mPixmap.width() / 2, -1 * mPixmap.height() / 2);

        //绘制的同时图片大小进行相应变化，让效果更明显
        painter.drawPixmap(0, 0, mPixmap.width() * mWidthK, mPixmap.height() * mWidthK, mPixmap);

    } else if (playType == WINDOWBLINDTYPE)
    {
        //百叶窗 主要显示的都在叶子中，所有此时调用默认paintEvent则可
        QLabel::paintEvent(event);
    } else if (playType == FADEOUTTYPE)
    {
        //淡出模式
        //设置相应的透明度，然后绘制出图片则可
        painter.setOpacity(openness);
        painter.drawImage(0,  0, mImg);
    }

}


/*******************************************
  description:飞入插入方式 定时器的槽函数，主要用来给于一定的显示时间和切换到下一张图片
  parameter：
  ******************************************/
void PixPlayLabel::flyTimerSlot()
{

    mFlyPosK  = mFlyPosK - mWidth / mTimerK;

    this->repaint();

    if(mFlyPosK <= 0)
    {
        mFlyTimer->stop();
        mFlyPosK = mWidth;

        if (isGifPix)
            showTimer->start(100);
        else
            showTimer->start(showTime);

        this->changePix();
    }
}

/*******************************************
  description:显示 定时器的槽函数，主要用来为启动相对应的播放方式的定时器
  parameter：
  ******************************************/
void PixPlayLabel::showTimerSlot()
{
    showTimer->stop();
    mTimeId = playDuration / 5;

    //如果动作时间太长的话，则规定在3秒之内
    if (mTimeId >= PLAYTIME)
    {
        mTimeId = PLAYTIME;
    }
    showTime = playDuration - mTimeId;


    if (playType == NORMALTYPE)
    {
        changePix();
        mNormalTimer->start(playDuration);
        update();

    } else if (playType == FLYTYPE)
    {
        if (mPlayNum == 1 && endFlag)
        {
            this->stop();
            showTimer->start(ENDTIME);
            endFlag = false;
            isPlayStop = true;
            emit playFinish(1, mNumber);
            return;
        }

        //如果是GIF图片则定时器时间直接定图片显示总时间，用来播放GIF图片效果
        if (isGifPix)
        {
            this->setMovie(movie);
            movie->start();
            mFlyPosK = 0;
            mFlyTimer->start(playDuration - 100);
        } else {
            mFlyTimer->start(mTimeId / mTimerK);
        }


    } else if (playType == RORATETYPE)
    {
        //一轮播放完了的时候等待2秒钟，如果不需要停止继续循环播放
        if (mPlayNum == 1 && endFlag)
        {
            this->stop();
            showTimer->start(ENDTIME);
            endFlag = false;
            isPlayStop = true;
            emit playFinish(1, mNumber);
            return;
        }

        //如果是GIF图片则定时器时间直接定图片显示总时间，用来播放GIF图片效果
        if (isGifPix)
        {
//            qDebug() << "RORATETYPE into setMovie=========>" << isGifPix;
            rotateTimer->start(playDuration - 100);
            this->setMovie(movie);
            movie->stop();
            movie->start();
            isPlayStop = true;
            rorateDegrees = 0;
        } else {
            rotateTimer->start(mTimeId / mTimerK);
        }

    } else if (playType == WINDOWBLINDTYPE)
    {
        //一轮播放完了的时候等待2秒钟，如果不需要停止继续循环播放
        if (mPlayNum == 1 && endFlag)
        {
            this->stop();
            showTimer->start(ENDTIME);
            endFlag = false;
            isPlayStop = true;
            emit playFinish(1, mNumber);
            return;
        }
        this->windowBlindsPlay();

    } else if (playType == FADEOUTTYPE)
    {
        //一轮播放完了的时候等待2秒钟，如果不需要停止继续循环播放
        if (mPlayNum == 0 && endFlag)
        {
            this->stop();
            showTimer->start(ENDTIME);
            endFlag = false;
            isPlayStop = true;
            emit playFinish(1, mNumber);
            return;
        }

        //换图片和透明度要在这里转换，不然会影响显示效果
        this->changePix();
        openness = 0.1;

        //如果是GIF图片则定时器时间直接定图片显示总时间，用来播放GIF图片效果
        if (isGifPix)
        {
            foTimer->start(playDuration - 100);
            this->setMovie(movie);
            movie->start();
            openness = 1;
        } else {
            foTimer->start(mTimeId / mTimerK);
        }
    }



    endFlag = true;

}


/*******************************************
  description:旋转播放方式 定时器的槽函数，主要用来给于一定的显示时间和切换到下一张图片
  parameter：
  ******************************************/
void PixPlayLabel::rorateTimerSlot()
{
    rorateDegrees += 180 / mTimerK;
    mWidthK += 0.1;

    this->repaint();

    if(rorateDegrees >= 0)
    {
        rotateTimer->stop();

        //如果是GIF图片则直接切换到一张图片，不用停止显示时间
        if (isGifPix)
        {
            showTimer->start(100);
        } else {
            showTimer->start(showTime);
        }

        this->changePix();
        rorateDegrees = RORATEDEGREES;
        mWidthK = 0.1;
    }

}

/*******************************************
  description:百叶窗播放方式 定时器的槽函数，主要用来给于一定的显示时间和切换到下一张图片
  parameter：
  ******************************************/
void PixPlayLabel::windowBlindsTimerSlot()
{

    // 开始动画
    wBTImer->stop();

    for(int i = 0; i < maxBlindsNum; i++)
    {
        wbItem[i]->stopDraw();
    }

    //如果是GIF图片则直接切换到一张图片，不用停止显示时间
    if (isGifPix)
        showTimer->start(100);
    else
        showTimer->start(showTime);

    this->changePix();

    update();
}

/*******************************************
  description:淡出播放方式 定时器的槽函数，主要用来给于一定的显示时间和切换到下一张图片
  parameter：
  ******************************************/
void PixPlayLabel::fadeOutTimerSlot()
{

    openness += 0.05;

    if (openness >= 1)
    {
        foTimer->stop();

        //如果是GIF图片则直接切换到一张图片，不用停止显示时间
        if (isGifPix)
            showTimer->start(100);
        else
            showTimer->start(showTime);

    }
    update();




}

/*******************************************
  description:普通播放方式 定时器的槽函数，主要用来给于一定的显示时间和切换到下一张图片
  parameter：
  ******************************************/
void PixPlayLabel::normalTimerSlot()
{
    if (mPlayNum == 0)
    {
        this->stop();
        showTimer->start(ENDTIME);
        return;
    }

    changePix();
    mNormalTimer->start(playDuration);
    update();
}
